{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Actor Critic Policy Optimization with PyTorch\n",
    "\n",
    "In this notebook, we will look at policy optimization using PyTorch. Let us quickly go through the derivation of what is policy Optimization and then we will apply this to CartPole environment. \n",
    "\n",
    "\n",
    "### Derivation of Policy Gradient\n",
    "In Policy Optimization, we will have a neural network which takes in state `s` as input and produces the `logits` for action probabilities. \n",
    "\n",
    "The policy is parameterized by $\\theta$\n",
    "$$\\pi_\\theta(a|s)$$\n",
    "\n",
    "The agent follows the policy and generates the trajectory $\\large \\tau$ \n",
    "\n",
    "$$ s_1 \\rightarrow a_1 \\rightarrow s_2 \\rightarrow a_2 \\rightarrow .... \\rightarrow s_{T-1} \\rightarrow a_{T-1} \\rightarrow s_T \\rightarrow a_T$$ \n",
    "\n",
    "here $s_T$ is not necessarily the terminal state but some time horizon T upto which we are looking at the trajectory. \n",
    "\n",
    "The probability of trajectory $\\large \\tau$ depends on the transition probabilities $p(s_t+1 | s_t, a_t)$ and the policy $\\pi_\\theta(a_t|s_t)$. It is given by the expression:\n",
    "\n",
    "$$p_\\theta(\\tau) = p_\\theta(s_1, a_1, s_2, a_2, ..., s_T, a_T) = p(s_1)\\prod_{t=1}^{T}\\pi_\\theta(a_t|s_t)p(s_{t+1}|s_t,a_t)$$\n",
    "\n",
    "The expected return from following the policy $\\pi$ is given by:\n",
    "\n",
    "$$J(\\theta) = {\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ \\sum_{t} \\gamma^t r(s_t, a_t) \\right]$$\n",
    "\n",
    "We want to find the $\\theta$ which maximizes the expected reward/return $J(\\theta)$. In other words, the optimal $\\theta=\\theta^*$ is given by expression\n",
    "\n",
    "$$\\theta^* = arg \\underset{\\theta}{max}{\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ \\sum_{t} \\gamma^t r(s_t, a_t) \\right] $$\n",
    "\n",
    "Moving on, let us try to find the optimal $\\theta$. To keep the notations easier to understand, we will replace $\\sum_{t} \\gamma^t r(s_t, a_t)$ as $r(\\tau)$:\n",
    "\n",
    "$$J(\\theta) = {\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ r(\\tau) \\right] = \\int p_\\theta(\\tau)r(\\tau) d\\tau$$\n",
    "\n",
    "We take the gradient/derivative of above expression with respect to $\\theta$:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\nabla_{\\theta} \\int p_\\theta(\\tau)r(\\tau) d\\tau $$\n",
    "\n",
    "By linearity we can move the gradient inside the integral:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\int \\nabla_{\\theta} p_\\theta(\\tau)r(\\tau) d\\tau $$\n",
    "\n",
    "Using log derivative trick, we know that $\\nabla_x f(x) = f(x) \\nabla_x \\log{f(x)}$. Using this we can write above expression as:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\int p_\\theta(\\tau) \\left[ \\nabla_{\\theta}\\log{p_\\theta(\\tau)} r(\\tau) \\right] d\\tau $$\n",
    "\n",
    "We can now write the integral back as expectation, which gives us the expression:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  {\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ \\nabla_{\\theta}\\log{p_\\theta(\\tau)} r(\\tau) \\right] $$\n",
    "\n",
    "Let us now expand the term $\\nabla_{\\theta}\\log{p_\\theta(\\tau)}$ by writing out the full expression of $p_\\theta(\\tau)$. \n",
    "\n",
    "$$ \\nabla_{\\theta}\\log{p_\\theta(\\tau)}  = \\nabla_{\\theta} \\log{ \\left[ p(s_1) \\prod_{t=1}^{T}\\pi_\\theta(a_t|s_t)p(s_{t+1}|s_t,a_t)\\right]}$$\n",
    "\n",
    "We know that log of product of terms can be written as sum of log of terms i.e. \n",
    "\n",
    "$$\\log{\\prod_i f_i(x)} = \\sum_i log{f_i(x)}$$ \n",
    "\n",
    "Using the above substitution, we get:\n",
    "\n",
    "$$ \\nabla_{\\theta}\\log{p_\\theta(\\tau)}  = \\nabla_{\\theta} \\left[ log{p(s_1)} +  \\sum_{t=1}^{T} \\left\\{ \\log{ \\pi_\\theta(a_t|s_t)} + \\log{p(s_{t+1}|s_t,a_t)} \\right\\} \\right]$$\n",
    "\n",
    "The only term dependent on $\\theta$ is $\\pi_\\theta(a_t|s_t)$. The other two terms $log{p(s_1)}$ and $\\log{p(s_{t+1}|s_t,a_t)}$ do not depend on $\\theta$. Accordingly, we can simplify the above expression as:\n",
    "\n",
    "$$ \\nabla_{\\theta}\\log{p_\\theta(\\tau)}  = \\sum_{t=1}^{T} \\nabla_{\\theta} \\log{ \\pi_\\theta(a_t|s_t)} $$\n",
    "\n",
    "\n",
    "Substituting the above term into the expression for $\\nabla_{\\theta} J(\\theta)$, as well as expanding $r(\\tau)$ we get:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  {\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ \\left( \\sum_{t=1}^{T} \\nabla_{\\theta} \\log{ \\pi_\\theta(a_t|s_t)} \\right) \\left( \\sum_{t=1}^{T} \\gamma^t r(s_t, a_t) \\right) \\right] $$\n",
    "\n",
    "We can now replace the outer expectation with an estimate over multiple trajectories to get the following expression for the gradient of policy objective:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ \\left( \\sum_{t=1}^{T} \\nabla_{\\theta} \\log{ \\pi_\\theta(a_t^i|s_t^i)} \\right) \\left( \\sum_{t=1}^{T} \\gamma^t r(s_t^i, a_t^i) \\right) \\right] $$\n",
    "\n",
    "where i denotes the $i^{th}$ trajectory. \n",
    "\n",
    "To improve the policy, we now take a +ve step in $\\theta$ in the direction of $\\nabla_{\\theta} J(\\theta)$:\n",
    "\n",
    "$$\\theta = \\theta + \\alpha \\nabla_{\\theta} J(\\theta)$$\n",
    "\n",
    "To summarize, we design a model which takes state $s$ as input and produces the policy distribution $\\pi_\\theta(a|s)$ as the output of the model. We use a policy to generate returns and then change the model parameter $\\theta$ using the expression: $\\theta = \\theta + \\alpha \\nabla_{\\theta} J(\\theta)$\n",
    "\n",
    "\n",
    "### Rewards to Go Trick\n",
    "\n",
    "\n",
    "we drop the reward terms that came before time t as at time t, the action we take can only impact the reward which comes at time t and later. This leads to changing the 2nd inner sum going from t’=t to T instead of earlier sum over t’ going from t’=1 to T. i.e. the start index is now t’=t and not t=1. The revised expression is given below:\n",
    "\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[  \\sum_{t=1}^{T}  \\left( \\nabla_{\\theta} \\log{ \\pi_\\theta(a_t^i|s_t^i)} \\sum_{t'=t}^{T} \\gamma^{t'-t} r(s_{t'}^i, a_{t'}^i) \\right) \\right] $$\n",
    "\n",
    "\n",
    "\n",
    "### Baseline Trick\n",
    "We can further reduce the variance using base line to get:\n",
    "\n",
    "$$\\nabla_\\theta J\\left(\\theta\\right)=\\frac{1}{N}\\sum_{i=1}^{N}\\sum_{t=1}^{T}{\\nabla_\\theta\\log{\\pi_\\theta\\left(a_t^i\\middle| s_t^i\\right)\\ }\\left[\\hat{Q}(s_t^i,\\ a_t^i) - b\\left(s_t^i\\right)\\right]\\\\}$$\n",
    "\n",
    "where:\n",
    "\n",
    "$$\\hat{Q}(s_t^i,\\ a_t^i)=\\ \\sum_{t^\\prime=t}^{T} \\gamma^{t'-t} r\\left(s_{t^\\prime}^i,a_{t^\\prime}^i\\right)$$\n",
    "\n",
    "\n",
    "### Actor Critic\n",
    "In Actor Critic, we fit the baseline to an estimator for state value V. We use a model as given below:\n",
    "\n",
    "\n",
    "![Actor Critic](./images/actor_critic.png \"Actor Critic\")\n",
    "\n",
    "\n",
    "\n",
    "The final update rule under Actor Critic is given below:\n",
    "\n",
    "$$\\nabla_{\\theta,\\phi} J\\left(\\theta,\\phi \\right)=\\frac{1}{N}\\sum_{i=1}^{N}\\sum_{t=1}^{T}{\\nabla_\\theta\\log{\\pi_\\theta\\left(a_t^i\\middle| s_t^i\\right)\\ }\\left[ \\hat{Q}(s_t^i,\\ a_t^i) -\\ V_\\phi(s_t^i)\\right]\\ }$$\n",
    "\n",
    "\n",
    "### Implementing Loss and Gradient Step in PyTorch\n",
    "\n",
    "We will implement a pseudo loss function, whose derivative will give us $\\nabla_{\\theta,\\phi} J\\left(\\theta,\\phi \\right)$. Also as PyTorch/TensorFlow carryout a gradient Step, we will convert maximization to minimization by changing the sign of this objective function\n",
    "\n",
    "$$L_{CrossEntropy}(\\theta, \\phi) = - J(\\theta, \\phi) = - \\frac{1}{N} \\sum_{i=1}^{N}  \\sum_{t=1}^{T} \\left( \\log{\\pi_\\theta (a_t^i | s_t^i) } \\left[ \\hat{Q}(s_t^i,\\ a_t^i) - V_\\phi(s_t^i)\\right] \\right)$$\n",
    "\n",
    "To summarize, we will pass the state `s` through the network to get $\\log{ \\pi_\\theta(a_t^i|s_t^i)}$ and $V_\\phi(s_t)$. We will calculate the cross_entropy loss for the actions actually seen in the trajectory. We will then calculate the weighted mean of these individual loss terms in the trajectory with weights being the Advantage $\\hat{A}(s_t^i,\\ a_t^i) = \\hat{Q}(s_t^i,\\ a_t^i) - V_\\phi(s_t^i)$\n",
    "\n",
    "This will be followed by a gradient step in -ve direction of weighted NLL (negative log loss) i.e. in positive direction of the gradient of $J(\\theta, \\phi)= - L_{CrossEntropy}(\\theta, \\phi)$ \n",
    "\n",
    "We also add a regularization term known as Entropy. Entropy of a distribution is defined as:\n",
    "\n",
    "$$H(X) = \\sum_x -p(x).log(p(x))$$\n",
    "\n",
    "To keep enough exploration, we will want the probability to have a spread out distribution and not let the probability distribution to collapse to a single value or a small region too soon. Bigger the spread of a distribution, higher the entropy H(x) of a distribution. Accordingly, the term fed into PyTorch/TensorFlow minimizer is:\n",
    "\n",
    "\n",
    "$$Loss(\\theta, \\phi) = - J(\\theta, \\phi) - H(\\pi_\\theta(a_t^i|s_t^i)) = - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ \\sum_{t=1}^{T} \\left(  \\log{ \\pi_\\theta(a_t^i|s_t^i)} \\left[ \\hat{Q}(s_t^i,\\ a_t^i) - V_\\phi(s_t^i)\\right] \\right) - \\beta \\sum_a \\pi_\\theta(a|s_t^i).\\log{ \\pi_\\theta(a|s_t^i)} \\right] $$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab\n",
    "\n",
    "# !apt-get update && apt-get install swig cmake ffmpeg freeglut3-dev xvfb\n",
    "# !pip install box2d-py\n",
    "# !pip install \"stable-baselines3[extra]>=2.1\"\n",
    "# !pip install \"huggingface_sb3>=3.0\"\n",
    "\n",
    "# !pip install git+https://github.com/DLR-RM/rl-baselines3-zoo@update/hf\n",
    "# !git clone https://github.com/DLR-RM/rl-baselines3-zoo\n",
    "# %cd rl-baselines3-zoo/\n",
    "# !pip install -r requirements.txt\n",
    "# %cd ..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-01-11 15:51:34.250427: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2024-01-11 15:51:34.252937: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2024-01-11 15:51:34.290856: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-01-11 15:51:34.290894: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-01-11 15:51:34.290914: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2024-01-11 15:51:34.298032: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2024-01-11 15:51:34.299709: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-01-11 15:51:35.079299: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "\n",
    "from IPython.display import HTML, clear_output\n",
    "from base64 import b64encode\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole and they try to run this on many other environments like Atari games and others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=123\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "state_dim = state_shape[0]\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Actor Critic Network\n",
    "\n",
    "We will build two simple networks that take in state. One network produces logits for the action probabilities. 2nd network produces the Value of the state. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "Each model will be a simple one with 1 hidden layer with Relu activation and final layer being logits (for policy/actor network) and value of the state for the Critic Network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActorCritic(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ActorCritic, self).__init__()\n",
    "        self.fc1 = nn.Linear(state_dim, 128)\n",
    "        self.actor = nn.Linear(128,n_actions)\n",
    "        self.critic = nn.Linear(128,1)\n",
    "\n",
    "\n",
    "    def forward(self, s):\n",
    "        x = nn.functional.relu(self.fc1(s))\n",
    "        logits = self.actor(x)\n",
    "        state_value = self.critic(x)\n",
    "        return logits, state_value\n",
    "        \n",
    "model = ActorCritic()\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict Action Probabilities\n",
    "\n",
    "We will use this function to generate the trajectory. It will not be used for doing back propagation. So we will use PyTorch `no_grad()` to avoid gradient calculations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_action(state):\n",
    "    \"\"\"\n",
    "    params: states: [batch, state_dim]\n",
    "    returns: probs: [batch, n_actions]\n",
    "    \"\"\"\n",
    "    state = torch.tensor(state, device=device, dtype=torch.float32)\n",
    "    with torch.no_grad():\n",
    "        logits,_ = model(state)\n",
    "    action_probs = nn.functional.softmax(logits, -1).detach().cpu().numpy()[0]\n",
    "    action = np.random.choice(n_actions, p=action_probs)\n",
    "    return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Play game and generate Trajectory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_trajectory(env, n_steps=1000):\n",
    "    \"\"\"\n",
    "    Play a session and genrate a trajectory\n",
    "    returns: arrays of states, actions, rewards\n",
    "    \"\"\"\n",
    "    states, actions, rewards = [], [], []\n",
    "    \n",
    "    # initialize the environment\n",
    "    s,_ = env.reset()\n",
    "    \n",
    "    #generate n_steps of trajectory:\n",
    "    for t in range(n_steps):\n",
    "        #sample action based on action_probs\n",
    "        a = sample_action(np.array([s]))\n",
    "        next_state, r, done, _, _ = env.step(a)\n",
    "        \n",
    "        #update arrays\n",
    "        states.append(s)\n",
    "        actions.append(a)\n",
    "        rewards.append(r)\n",
    "\n",
    "        s = next_state\n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "    return np.array(states), np.array(actions), np.array(rewards)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluation of Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=3, t_max=10000):\n",
    "    rewards = []\n",
    "    for i in range(n_games):\n",
    "        s,_ = env.reset(seed=seed+i)\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            #sample action based on action_probs\n",
    "            a = sample_action(np.array([s]))\n",
    "            next_state, r, terminated, _, _ = env.step(a)\n",
    "            reward += r\n",
    "            s = next_state\n",
    "            if terminated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Rewards to Go\n",
    "\n",
    " $G(s_t) = \\sum_{t'=t}^{T} \\gamma^{t-t'} r(s_{t'}^i, a_{t'}^i)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rewards_to_go(rewards, gamma=0.99):\n",
    "    \n",
    "    T = len(rewards) # total number of individual rewards\n",
    "    # empty array to return the rewards to go\n",
    "    rewards_to_go = [0]*T \n",
    "    rewards_to_go[T-1] = rewards[T-1]\n",
    "    \n",
    "    for i in range(T-2, -1, -1): #go from T-2 to 0\n",
    "        rewards_to_go[i] = gamma * rewards_to_go[i+1] + rewards[i]\n",
    "    \n",
    "    return rewards_to_go"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train on one trajectory\n",
    "\n",
    "We will calculate the loss and take a gradient step. We will use Adam Optimizer\n",
    "\n",
    "**policy network loss:**\n",
    "\n",
    "We are taking only one trajectory. so N=1. We will, however, average it over the number of actions to get the average loss. So the function we will actually implement is as given below:\n",
    "\n",
    "\n",
    "$$Loss(\\theta, \\phi) = - J(\\theta, \\phi) - H(\\pi_\\theta(a_t|s_t)) = - \\frac{1}{T}  \\left[ \\sum_{t=1}^{T} \\left(  \\log{ \\pi_\\theta(a_t|s_t)} \\left[ \\hat{Q}(s_t,\\ a_t) - V_\\phi(s_t)\\right] \\right) - \\beta \\sum_{a} \\pi_\\theta(a|s_t).\\log{ \\pi_\\theta(a|s_t)} \\right] $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#init Optimizer\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
    "\n",
    "def train_one_episode(states, actions, rewards, gamma=0.99, entropy_coef=1e-2):\n",
    "    \n",
    "    # get rewards to go\n",
    "    rewards_to_go = get_rewards_to_go(rewards, gamma)\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards_to_go = torch.tensor(rewards_to_go, device=device, dtype=torch.float)\n",
    "    \n",
    "\n",
    "    # get action probabilities from states\n",
    "    logits, state_values = model(states)\n",
    "    probs = nn.functional.softmax(logits, -1)\n",
    "    log_probs = nn.functional.log_softmax(logits, -1)\n",
    "    \n",
    "    log_probs_for_actions = log_probs[range(len(actions)), actions]\n",
    "    \n",
    "    advantage = rewards_to_go - state_values.squeeze(-1)\n",
    "    \n",
    "    #Compute loss to be minimized\n",
    "    J = torch.mean(log_probs_for_actions*(advantage))\n",
    "    H = -(probs*log_probs).sum(-1).mean()\n",
    "    \n",
    "    loss = -(J+entropy_coef*H)\n",
    "\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    return loss.detach().cpu() #to show progress on training\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_freq = 10\n",
    "n_episodes = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss_history = []\n",
    "return_history = []\n",
    "\n",
    "for i in range(5000):\n",
    "    states, actions, rewards = generate_trajectory(env)\n",
    "    loss = train_one_episode(states, actions, rewards)\n",
    "    # return_history.append(np.sum(rewards))\n",
    "    loss_history.append(loss)\n",
    "\n",
    "    if i != 0 and i % eval_freq == 0:\n",
    "        mean_return = np.mean(return_history[-eval_freq:])\n",
    "        if mean_return > 500:\n",
    "            break\n",
    "\n",
    "    if i != 0 and i % eval_freq == 0:\n",
    "        # eval the agent\n",
    "        eval_env = make_env(env_name)\n",
    "        return_history.append(\n",
    "            evaluate(eval_env, model)\n",
    "        )\n",
    "        eval_env.close()\n",
    "        clear_output(True)\n",
    "\n",
    "        plt.figure(figsize=[16, 5])\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.title(\"Mean return per episode\")\n",
    "        plt.plot(return_history)\n",
    "        plt.grid()\n",
    "\n",
    "        assert not np.isnan(loss_history[-1])\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.title(\"Loss history (smoothened)\")\n",
    "        plt.plot(smoothen(loss_history))\n",
    "        plt.grid()\n",
    "\n",
    "        plt.show()\n",
    "\n",
    "\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = sample_action(obs)\n",
    "        obs, _, _, _ = vec_env.step([action])\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter8/logs/8_b/ActorCritic-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter8/logs/8_b/ActorCritic-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter8/logs/8_b/ActorCritic-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter8/logs/8_b/ActorCritic-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/8_b/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, model)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "In this notebook we saw how A2C works. From the graphs we can notice that Grpahs of learning are lot smoother and policy learnt by the agent is also of higher quality as comapred to REINFORCE."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
